import axios from 'axios'
import { ElMessage } from 'element-plus'
import { useUserStore } from '@/stores/user'
import { STORAGE_KEYS } from '@/utils/constants'

// 请求日志工具函数
const logRequest = (config) => {
  const timestamp = new Date().toLocaleString()
  console.group(`[API请求] ${timestamp}`)
  console.log('URL:', `${config.baseURL || ''}${config.url}`)
  console.log('Method:', config.method?.toUpperCase())
  console.log('Headers:', config.headers)
  if (config.params) {
    console.log('Query Params:', config.params)
  }
  if (config.data) {
    console.log('Request Data:', config.data)
  }
  console.groupEnd()
}

const logResponse = (response) => {
  const timestamp = new Date().toLocaleString()
  console.group(`[API响应] ${timestamp}`)
  console.log('URL:', response.config.url)
  console.log('Status:', response.status)
  console.log('Response Data:', response.data)
  console.groupEnd()
}

const logError = (error) => {
  const timestamp = new Date().toLocaleString()
  console.group(`[API错误] ${timestamp}`)
  if (error.config) {
    console.log('URL:', error.config.url)
    console.log('Method:', error.config.method?.toUpperCase())
  }
  if (error.response) {
    console.log('Status:', error.response.status)
    console.log('Error Data:', error.response.data)
  } else {
    console.log('Error Message:', error.message)
  }
  console.groupEnd()
}

// 获取CSRF Token
function getCSRFToken() {
  const cookieToken = document.cookie.match(/X-CSRF-TOKEN=([^;]+)/)
  if (cookieToken) return cookieToken[1]
  
  const metaToken = document.querySelector('meta[name="csrf-token"]')
  if (metaToken) return metaToken.getAttribute('content')
  
  return null
}

// 创建axios实例
const request = axios.create({
  baseURL: 'http://localhost:8080/api',  // 直接请求后端8080端口
  timeout: 30000,
  headers: {
    'Content-Type': 'application/json',
  },
  withCredentials: true
})

// 请求拦截器 - 修复token获取逻辑
request.interceptors.request.use(
  (config) => {
    // 记录请求
    logRequest(config)
    
    // 跳过登出请求和登录请求的token检查
    const noAuthUrls = ['/auth/logout', '/auth/login', '/auth/register']
    if (noAuthUrls.includes(config.url)) {
      console.log('无需认证的请求,跳过token检查:', config.url)
      return config
    }
    
    // 优先从 localStorage 获取 token（更可靠）
    let token = localStorage.getItem(STORAGE_KEYS.TOKEN) || sessionStorage.getItem(STORAGE_KEYS.TOKEN)
    
    // 如果本地存储没有token，尝试从 Pinia store 获取
    if (!token) {
      try {
        const userStore = useUserStore()
        token = userStore.token
        console.log('从 Pinia store 获取token:', token ? `有token (${token.substring(0, 10)}...)` : '无token')
      } catch (error) {
        console.warn('Pinia store 获取失败，回退到本地存储')
      }
    } else {
      console.log('从本地存储获取token:', token ? `有token (${token.substring(0, 10)}...)` : '无token')
    }
    
    // 添加token到请求头
    if (token) {
      config.headers.Authorization = `Bearer ${token}`
      console.log('已添加认证token到请求头')
    } else {
      console.warn('未找到认证token')
    }
    
    // 添加CSRF token（如果需要）
    const csrfToken = getCSRFToken()
    if (csrfToken) {
      config.headers['X-CSRF-TOKEN'] = csrfToken
    }
    
    return config
  },
  (error) => {
    logError(error)
    return Promise.reject(error)
  }
)

// 响应拦截器
request.interceptors.response.use(
  (response) => {
    // 记录响应
    logResponse(response)
    
    // 统一处理响应格式
    const data = response.data
    
    // 如果后端返回统一的格式 { code, message, data }
    if (data && typeof data.code !== 'undefined') {
      if (data.code === 200) {
        return data // 返回成功的数据
      } else {
        // 业务逻辑错误
        ElMessage.error(data.message || '操作失败')
        return Promise.reject(new Error(data.message || '操作失败'))
      }
    }
    
    // 如果没有统一格式，直接返回数据
    return data
  },
  (error) => {
    // 记录错误
    logError(error)
    
    const { response } = error
    const status = response?.status
    
    // 处理HTTP错误状态码
    if (status === 401) {
      console.error('认证失败，请重新登录')
      ElMessage.error('登录已过期，请重新登录')
      
      // 使用store登出
      try {
        const userStore = useUserStore()
        userStore.logout()
      } catch (e) {
        // 如果store不可用，直接清除本地存储
        localStorage.removeItem(STORAGE_KEYS.TOKEN)
        localStorage.removeItem(STORAGE_KEYS.USER_INFO)
        sessionStorage.removeItem(STORAGE_KEYS.TOKEN)
        sessionStorage.removeItem(STORAGE_KEYS.USER_INFO)
      }
      
      // 跳转到登录页
      setTimeout(() => {
        window.location.href = '/login?redirect=' + encodeURIComponent(window.location.pathname)
      }, 1500)
    } else if (status === 403) {
      console.error('权限不足')
      ElMessage.error('权限不足，请联系管理员')
    } else if (status === 404) {
      // 对于登出接口的404错误，不显示错误消息，直接本地登出
      if (error.config?.url === '/auth/logout') {
        console.log('登出接口不存在，执行本地登出')
        const userStore = useUserStore()
        userStore.logout()
        return Promise.resolve({ code: 200, message: '登出成功' })
      } else {
        ElMessage.error('请求的接口不存在')
      }
    } else if (status >= 500) {
      ElMessage.error('服务器内部错误，请稍后重试')
    } else if (error.code === 'ERR_NETWORK') {
      // 网络错误时，如果是登出请求，执行本地登出
      if (error.config?.url === '/auth/logout') {
        console.log('网络错误，执行本地登出')
        const userStore = useUserStore()
        userStore.logout()
        return Promise.resolve({ code: 200, message: '登出成功' })
      } else {
        ElMessage.error('网络连接失败，请检查服务器状态')
      }
    } else {
      ElMessage.error(error.message || '网络错误')
    }
    
    return Promise.reject(error)
  }
)

export default request